package org.example.scoresystem_backen.controller;

import org.example.scoresystem_backen.common.Result;
import org.example.scoresystem_backen.entity.Course;
import org.example.scoresystem_backen.service.CourseService;
import org.example.scoresystem_backen.dto.PageRequest;
import org.example.scoresystem_backen.dto.PageResponse;
import org.example.scoresystem_backen.dto.CourseOptionDTO;
import org.example.scoresystem_backen.util.AuthUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;

/**
 * 课程控制器 - RESTful API
 * 支持分页查询、搜索筛选、级联删除等功能
 */
@RestController
@RequestMapping("/api/courses")
@CrossOrigin(origins = "*")
public class CourseController {

    @Autowired
    private CourseService courseService;
    
    /**
     * 分页查询课程列表（支持搜索和筛选）
     * @param page 页码（默认1）
     * @param pageSize 每页条数（默认10，最大100）
     * @param search 搜索关键词（按课程名称或代码模糊查询）
     * @param credits 学分筛选
     * @return 分页响应结果
     */
    @GetMapping
    public Result<PageResponse<Course>> getCourses(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10", name = "page_size") Integer pageSize,
            @RequestParam(required = false) String search,
            @RequestParam(required = false) BigDecimal credits) {
        try {
            // 权限检查：需要登录
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            // 构建分页请求
            PageRequest pageRequest = new PageRequest();
            pageRequest.setPage(page);
            pageRequest.setPageSize(pageSize);
            pageRequest.setCredits(credits);

            // 处理搜索条件（可以是课程名称或代码）
            if (search != null && !search.trim().isEmpty()) {
                // 简化处理：同时搜索课程名称和代码
                pageRequest.setCourseName(search);
                pageRequest.setCourseCode(search);
            }

            PageResponse<Course> response = courseService.findCoursesWithPagination(pageRequest);
            return Result.success("查询成功", response);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 创建课程
     * @param course 课程信息
     * @return 创建结果
     */
    @PostMapping
    public Result<Course> createCourse(@RequestBody Course course) {
        try {
            // 权限检查：只有管理员可以创建课程
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以创建课程");
            }

            Course createdCourse = courseService.createCourse(course);
            return Result.success("课程创建成功", createdCourse);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 更新课程信息
     * @param courseId 课程ID
     * @param course 课程信息
     * @return 更新结果
     */
    @PutMapping("/{courseId}")
    public Result<Course> updateCourse(@PathVariable Integer courseId, @RequestBody Course course) {
        try {
            // 权限检查：只有管理员可以更新课程
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以更新课程");
            }

            // 设置课程ID
            course.setId(courseId);
            Course updatedCourse = courseService.updateCourse(course);
            return Result.success("课程更新成功", updatedCourse);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 删除课程（级联删除相关成绩记录）
     * @param courseId 课程ID
     * @return 删除结果
     */
    @DeleteMapping("/{courseId}")
    public Result<Void> deleteCourse(@PathVariable Integer courseId) {
        try {
            // 权限检查：只有管理员可以删除课程
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以删除课程");
            }

            courseService.deleteCourseWithCascade(courseId);
            return Result.success("课程删除成功，相关成绩记录已同步删除");
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据ID查找课程
     * @param id 课程ID
     * @return 课程信息
     */
    @GetMapping("/{id}")
    public Result<Course> findById(@PathVariable Integer id) {
        try {
            Course course = courseService.findById(id);
            return Result.success(course);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 获取所有课程
     * @return 课程列表
     */
    @GetMapping("/all")
    public Result<List<Course>> findAll() {
        try {
            List<Course> courses = courseService.findAll();
            return Result.success(courses);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    

    
    /**
     * 根据课程名称查找课程
     * @param name 课程名称
     * @return 课程信息
     */
    @GetMapping("/name/{name}")
    public Result<Course> findByName(@PathVariable String name) {
        try {
            Course course = courseService.findByName(name);
            return Result.success(course);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据课程代码查找课程
     * @param code 课程代码
     * @return 课程信息
     */
    @GetMapping("/code/{code}")
    public Result<Course> findByCode(@PathVariable String code) {
        try {
            Course course = courseService.findByCode(code);
            return Result.success(course);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据学分查找课程列表
     * @param credits 学分
     * @return 课程列表
     */
    @GetMapping("/credits/{credits}")
    public Result<List<Course>> findByCredits(@PathVariable BigDecimal credits) {
        try {
            List<Course> courses = courseService.findByCredits(credits);
            return Result.success(courses);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据学分范围查找课程列表
     * @param minCredits 最小学分
     * @param maxCredits 最大学分
     * @return 课程列表
     */
    @GetMapping("/credits/range")
    public Result<List<Course>> findByCreditsBetween(@RequestParam BigDecimal minCredits,
                                                    @RequestParam BigDecimal maxCredits) {
        try {
            List<Course> courses = courseService.findByCreditsBetween(minCredits, maxCredits);
            return Result.success(courses);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据课程名称模糊查询课程
     * @param name 课程名称关键字
     * @return 课程列表
     */
    @GetMapping("/search/name")
    public Result<List<Course>> searchByName(@RequestParam String name) {
        try {
            List<Course> courses = courseService.findByNameContaining(name);
            return Result.success(courses);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 根据课程代码模糊查询课程
     * @param code 课程代码关键字
     * @return 课程列表
     */
    @GetMapping("/search/code")
    public Result<List<Course>> searchByCode(@RequestParam String code) {
        try {
            List<Course> courses = courseService.findByCodeContaining(code);
            return Result.success(courses);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 获取所有课程，按名称排序
     * @return 课程列表
     */
    @GetMapping("/ordered")
    public Result<List<Course>> findAllOrderByName() {
        try {
            List<Course> courses = courseService.findAllOrderByName();
            return Result.success(courses);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 获取课程选项列表（用于下拉选择）
     * @return 课程选项列表
     */
    @GetMapping("/options")
    public Result<List<CourseOptionDTO>> getCourseOptions() {
        try {
            // 权限检查：需要登录
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            List<CourseOptionDTO> options = courseService.getCourseOptions();
            return Result.success("获取课程选项成功", options);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 检查课程名称是否存在
     * @param name 课程名称
     * @return 是否存在
     */
    @GetMapping("/exists/name/{name}")
    public Result<Boolean> checkNameExists(@PathVariable String name) {
        try {
            // 权限检查：只有管理员可以检查
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以执行此操作");
            }

            boolean exists = courseService.existsByName(name);
            return Result.success(exists);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 检查课程代码是否存在
     * @param code 课程代码
     * @return 是否存在
     */
    @GetMapping("/exists/code/{code}")
    public Result<Boolean> checkCodeExists(@PathVariable String code) {
        try {
            // 权限检查：只有管理员可以检查
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以执行此操作");
            }

            boolean exists = courseService.existsByCode(code);
            return Result.success(exists);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
}
